{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:22:57.026884Z",
     "start_time": "2025-02-28T01:22:57.022485Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1 特征中含有字符串的时候（当成类别），如何做特征抽取"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化\n",
    "    # sparse改为True,输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    dict1 = DictVectorizer(sparse=True)  # 把sparse改为True看看\n",
    "\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 字典中的一些类别数据，分别进行转换成特征\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(dict1.inverse_transform(data))  #去看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "dictvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:22.156316Z",
     "start_time": "2025-02-28T01:11:22.148135Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:02:51.495532Z",
     "start_time": "2025-02-28T02:02:51.486049Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:22.187647Z",
     "start_time": "2025-02-28T01:11:22.169990Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.408548Z",
     "start_time": "2025-02-28T01:11:22.189646Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\25571\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 1.206 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.423741Z",
     "start_time": "2025-02-28T01:11:23.410548Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.436422Z",
     "start_time": "2025-02-28T01:11:23.426126Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.449365Z",
     "start_time": "2025-02-28T01:11:23.438422Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.510715Z",
     "start_time": "2025-02-28T01:11:23.451097Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.519653Z",
     "start_time": "2025-02-28T01:11:23.514708Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": [
    "type(data)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.619690Z",
     "start_time": "2025-02-28T01:11:23.521652Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.631607Z",
     "start_time": "2025-02-28T01:11:23.622419Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.650363Z",
     "start_time": "2025-02-28T01:11:23.633606Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.659842Z",
     "start_time": "2025-02-28T01:11:23.652363Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.672079Z",
     "start_time": "2025-02-28T01:11:23.661841Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "source": "11 / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.679210Z",
     "start_time": "2025-02-28T01:11:23.674077Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "source": "np.nan + 10",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.686196Z",
     "start_time": "2025-02-28T01:11:23.680211Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.697112Z",
     "start_time": "2025-02-28T01:11:23.688194Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.99)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.719712Z",
     "start_time": "2025-02-28T01:11:23.698114Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "source": "22 / 29.333333333333336",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:23.726938Z",
     "start_time": "2025-02-28T01:11:23.721711Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T01:11:25.484894Z",
     "start_time": "2025-02-28T01:11:23.728936Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 21
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
